COMMENT ⊗   VALID 00007 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	3.0	GEOMED AS A GEOMETRIC MODELING COMMAND LANGUAGE.
C00005 00003	3.1	Euler Routines.
C00009 00004		TABLE OF EULER ROUTINES
C00013 00005	3.2	Euclidean Routines.
C00015 00006		TABLE OF EUCLIDEAN ROUTINES.
C00017 00007	3.3	Image Synthesis Routines. {perspective projection}
C00018 ENDMK
C⊗;
3.0	GEOMED AS A GEOMETRIC MODELING COMMAND LANGUAGE.

	3.0	Introduction.
	3.1	Euler Routines.
	3.2	Euclidean Routines.
	3.3	Image Synthesis Routines.

3.0	Introduction.
	
	GEOMED  (Geometric Editor)  is a  system  of subroutines  for
manipulating  winged edge  polyhedra. The  system has  two distinctly
different manifestations:  first, it  appears as  an interactive  3-D
drawing  program and  second,   it  appears as  a geometric  modeling
command  language. It is the latter  manifestation along with some of
the details of  implementation that is  the subject of this  chapter.
GEOMED as  an interactive drawing program is  documented in reference
(**). As a language,  GEOMED is  all semantics with no syntax of  its
own; there are about  two hundred GEOMED subroutines which  take from
zero  to four arguments,  return one or  no values  and which usually
have  considerable  side   effects  on   the  data  structures.   The
subroutines can be grouped into  four groups: utility routines, Euler
routines,    Euclidean  Routines and  image  synthesis  routines. The
utility  routines  (which  will  not  be  further  detailed)  include
input/output,  trigonmetric functions,  memory management,  a command
scanner and  device dependent  display routines.   In  general,   the
Euler  routines  perform  topological  operations   on  links,    the
Euclidean  routines perform  geometric computations  on data  and the
image synthesis  routines  perform photographic  simulations  on  the
model as a whole.

	As  in  the  previous  chapter, the  language  notation  will
continue to be similar in appearance to ALGOL.
3.1	Euler Routines.

	The Euler routines  of GEOMED are  based on the idea  that an
arbitrary polyhedron can be created in steps that always maintain the
Euler relation: F-E+V=2*(B-H).   Topologically,   a simply  connected
Eulerian polyhedral  graph can  be built up  with only  four creation
primitives  which I have called:  MKBFV,  MKEV,   MKFE and GLUEE. The
prefixes "MK"  and "KL",   stand  for  "make" and  "kill". The  MKBFV
primitives  takes  no   arguments  and  creates  a  degenerate  point
polyhedron of one vertex,  one face and one body which is the minimal
non-zero binding satisfying the equation. The MKEV creates a new edge
and a new vertex  attached to the given vertex in the given face. The
MKFE creates a  new face  and a  new edge,   the new  edge is  placed
between the two given vertices. Finally the GLUEE creates a handle or
kills  a body node by  placing a new edge  between two given vertices
and by removing the second of the two given  faces. Complementing the
maker primitives there are  four kill primitives called KLBFEV, KLEV,
KLFE and UNGLUEE. Completing the  set, the ESPLIT routine  (mentioned
in section **) is classified as an alternate form of MKEV.
	
	In principle, the advantages of the pure Euler primitives are
that  they  assure  valid topology,    full  generality,   reasonable
simplicity and  they achieve a  semantic level  slightly higher  than
that  of  manipulating  the  polyhedral  nodes  and  links  directly.
However,   the Euler  primitives only  satisfy the first  of the five
conditions  defining  a  solid  polyhedron;  leaving   no  particular
restrictions on  surface orientation,  face/vertex  trivalence,  face
planarity, face convexity and surface self intersection. In practice,
the Euler  primitives serve  as a  topological foundation for  coding
further routines which embody more geometry.
	TABLE OF EULER ROUTINES
---------------------------------------------------------------------

B. EULER MAKE PRIMITIVES:

   1. 	BNEW ← MKBFV;   	Makes point polyhedron: 1 face, 1 vertex.
   2. 	VNEW ← MKEV(F,V);	Makes new edge and vertex such that:
				VNEW = NVT(ENEW); V = PVT(ENEW);
	VNEW ← ESPLIT(E);	Makes new edge and vertex...
   3. 	ENEW ← MKFE(V1,F,V2);   Makes new face and edge such that:
				FNEW = NFACE(ENEW); F = PFACE(ENEW);
				  V1 = PVT(ENEW);  V2 = NVT(ENEW).
   4. 	ENEW ← GLUEE(F1,V1,F2,V2);	Makes new edge, Kills F2,
				and makes a hole or kills a body.
				  V1 = PVT(ENEW);  V2 = NVT(ENEW).
C. EULER KILL PRIMITIVES:

   1. 	QNEW ← KLBFEV(Q);	Kills B.F.E.V. entity. {FKILL},{EKILL}
   2. 	   F ← KLFE(E);		Kills E and NFACE(E). Returns PFACE(E).
   3. 	   E ← KLEV(V);		Kills V and PED(V).   Returns other E of V.
	   V ← KLEV(E);		Kills E and NVT(E).   Returns PVT(E).
   4. 	FNEW ← UNGLUE(E);	Kills E; makes F;     Returns the new face,
				and kills a hole or makes a body.

D. FURTHER EULER ROUTINES:		

   1.	BODY ←	GLUE(FACE1,FACE2);	Removes face1 and face2.
   2.	QNEW ←	MKCOPY(ENTITY);		Copy an entity.
   3.	FACE ←	SWEEP(FACE,FLAG);	Make prism on face (or sweep wire).
   4.	FACE ←	ROTCOM(FACE);		Rotation sweep wire face completion.
   5.	PEAK ←	PYRAMID(FV);		Make pyramid on a face (or vertex).
   6.	BODY ←  FVDUAL(BODY);		Apply face/vertex duality to a body.
   7.	BNEW ←  MKCUBE(DX,DY,DZ);	Create right rectangular prism.
   8.	BNEW ←  MKCYLN(RADIUS,N,DZ);	Create cylinder approximation.
   9.	BNEW ←  MKBALL(RADIUS,M,N);	Create sphere approximation.
---------------------------------------------------------------------
3.2	Euclidean Routines.

	The  Euclidean routines  of  GEOMED  fall into  four  groups:
transformations,  metrics, frame makers and space simulators.

The  Euclidean transformation  primitives are  translation, rotation,
dilation and reflection (following  Klein's Erlangen Program,  1872).
The  Euclidean  metric  routines compute  distances,  angles,  areas,
volumes and inertia tensors; while the frame routines create or alter
frame nodes. Fundamental to these routines is the curious fact that a
frame  node has  two interpretations:  it may  be used  to  specify a
coordinate systems  or  it  may  be used  to  represent  a  Euclidean
transformation.
	
	The Euclidean routines  involving frames can be  explained in
terms of  the 4-D homogeneous coordinates  usual to computer graphics
then both frame of reference  and transformations can be viewed as  a
tensor. A tensor is a geometric object linear vector function.
	TABLE OF EUCLIDEAN ROUTINES.
---------------------------------------------------------------------
EUCLIDEAN TRANSFORMATIONS

	TRANS	←	TRANSL(XWD(FRAME,BODY),DX,DY,DZ);
	TRANS	←	ROTATE(XWD(FRAME,BODY),WX,WY,WZ);
	TRANS	←	SHRINK(XWD(FRAME,BODY),KX,KY,KZ);
	TRANS	←	APTRAN(ENTITY,TRANS);
	TRANS	←	INTRAN(TRAN);

FRAME MAKERS

	TRANS	←	MKROT1(PAN,TILT,SWING);		MAKE FROM EULER ANGLES.
	TRANS	←	MKFFRM(FACE);			MAKE FACE FRAME.
	TRANS	←	MKQFRM(WX,WY,WZ);		MAKE FROM ROTATION VECTOR.

FRAME ORTHONORMALIZATION.

	NORM(FRAME)	;NORMALIZATION TO UNIT VECTORS.
	ORTHO1(FRAME)	;ORTHOGONALIZE BY WORST CASE.
	ORTHO2(FRAME)	;ORTHOGONALIZE BY K ← (I CROSS J), J ← (K CROSS I).

METRIC ROUTINES.

	DETERM(FRAME)
	ANGL3V(V1,V2,V3)
	DISTANCE(ENTITY,ENTITY);
3.3	Image Synthesis Routines. {perspective projection}